home *** CD-ROM | disk | FTP | other *** search
/ PC Home MegaDisk 20 / PC Home MegaDisk 1994-05 Issue 20.img / HIGHCS.EXE / ARTICLE4.C next >
Encoding:
C/C++ Source or Header  |  1994-03-26  |  7.6 KB  |  288 lines
  1. /***************************************************************************
  2.  *                                                                         *
  3.  *   File Name:      ARTICLE4.C                                            *
  4.  *   Description:    Move a couple of big images over a complex background *
  5.  *   Notes:          Feel free to change the program to load any 320x200   *
  6.  *                   256 colour picture, the images will work just as      *
  7.  *                   nicely (see the warning about palettes, though).      *
  8.  *                                                                         *
  9.  *   Warning:        Once you start to use images and/or sprites over pre- *
  10.  *                   saved PCX pictures, you run into a problem: the       *
  11.  *                   palette used for the picture must be the same as the  *
  12.  *                   palette used to create the images, otherwise your     *
  13.  *                   sprites look damn peculiar.  Unfortunately, there's   *
  14.  *                   no way around this, and it requires some discipline   *
  15.  *                   when you create things in the first place.            *
  16.  *                                                                         *
  17.  *                   As of this month, there'll be three files included on *
  18.  *                   the disk:-                                            *
  19.  *                   HIGHC.OBJ   All the functions we've developed so far  *
  20.  *                   HIGHC.C     The source to them                        *
  21.  *                   HIGHC.H     A header file for structures and soforth  *
  22.  *                                                                         *
  23.  *                   You MUST tell your compiler/linker to include         *
  24.  *                   HIGHC.OBJ at link time, otherwise it won't be able to *
  25.  *                   find all the "basic" functions like g_SetVGA.         *
  26.  *                                                                         *
  27.  ***************************************************************************/
  28.  
  29. #include "highc.h"      // From now on, include this in every program
  30. #include "alloc.h"
  31. #include "stdlib.h"
  32. #include "stdio.h"
  33. #include "string.h"
  34.  
  35. #define NO_FILE   -1
  36. #define NOT_KNOWN -2
  37. #define PCX        1         // Just to make it read a bit nicer
  38.  
  39. typedef struct {
  40.         char far *ptr;
  41.         int  h, w;
  42.         int  t, l;
  43.         char far *sptr;
  44.         } IMAGE_DEFN;
  45.  
  46. IMAGE_DEFN img[30];
  47.  
  48. main()
  49. {
  50.  
  51. signed char x;
  52. unsigned char w, h, contin;
  53. char signature[25];
  54. int j, k;
  55.  
  56. sbptr   = farcalloc(64000, 1);      // Allocate the screen buffer
  57. palette = farcalloc(768, 1);        // Allocate the palette space
  58.  
  59. g_SetVGA();
  60. x=g_LoadScreen("article4.pcx");  // You can change this to any 320x200,
  61.                                  // 256-colour picture you like.
  62.  
  63. if (x != PCX)
  64.    {
  65.    g_SetTxt();
  66.    printf("Error!  Non-existent or non-PCX file ARTICLE4.PCX");
  67.    exit(0);
  68.    }
  69.  
  70.  
  71. load_img("malcolm.im", 0);  // This image bank contains two images - Malcolm
  72.                             // the Void heading east, and the same fellow
  73.                             // heading west.  Next month, Malcolm walks!
  74.  
  75. pasteimg(0, 5, 60);         // I've offset them slightly so you can see
  76. pasteimg(1, 300, 70);       // that image 1 appears to pass over the top of
  77.                             // image 0 when they cross.
  78.  
  79. /*  These pictures of Malcolm were originally drawn on an Amiga with a
  80.     slightly higher y-resolution than the PC, hence the "stretched" look.
  81.     Interestingly, when Sarah created these images she accidentally used
  82.     colour 0 as a black in several places, especially around Malcolm's boots.
  83.     I have left this error in so you can see how the image system treats ALL
  84.     occurences of colour 0 as see-through.  It's quite a nice effect,
  85.     actually...                                                          */
  86.  
  87. for (j=1; j<250; j++)       // Feel free to mess about with this loop to
  88.     {                       // your heart's content.  If you make j increment
  89.                             // by 2, 3 or even 4 each time, the movement will
  90.                             // still be acceptably smooth.
  91.     removeimg(1);
  92.     removeimg(0);           // ALWAYS remove images in the opposite order to
  93.                             // the order you placed them in.
  94.     pasteimg(0, 5+j, 60);
  95.     pasteimg(1, 300-j, 70);
  96.     g_SwapScr();
  97.     }
  98.  
  99. getch();
  100.  
  101. g_SetTxt();
  102.  
  103. return(OK);
  104. }
  105.  
  106. pasteimg(char imgnum, int l, int t)
  107.  
  108. {
  109.  
  110. unsigned int j, k, h, w, m, n;
  111. char far *sp1;
  112. char far *sp2;
  113.  
  114. if (imgnum < 0 || imgnum > 30)     // We're only allowing 30 images at one time
  115.    return(-1);                     // (could easily be increased)
  116.  
  117. if (l < 0 || t < 0 || l > 319 || t > 199)
  118.    return(-2);                     // Don't paste an image off the edge of
  119.                                    // the screen.
  120.  
  121. if ( (sp2 = img[imgnum].ptr) == NULL)
  122.    return(-3);                     // The requested image has no image data
  123.  
  124. w = img[imgnum].w;
  125. h = img[imgnum].h;
  126.  
  127. if (img[imgnum].sptr != NULL)      // If, for some reason, the background is
  128.    farfree(img[imgnum].sptr);      // already saved, throw it away
  129.  
  130. if ( (img[imgnum].sptr = farcalloc(w*h, 1)) == NULL)
  131.    return(-4);                     // Not enough memory to save background
  132.  
  133. save_IMG_back(imgnum, l, t);
  134.  
  135. m = 0;
  136.  
  137. for (j = 0; j < h; j++)
  138.     {
  139.     if (j+t < 200)
  140.        {
  141.        sp1 = g_FPtr(sbptr, (t * 320) + (j * 320) + l);
  142.        n = 0;
  143.        for (k = 0; k < w; k++)
  144.            {
  145.            if (sp2[m] != 0 && k+l < 320)
  146.               sp1[n] = sp2[m];
  147.            n++; m++;
  148.            }
  149.        }
  150.     }
  151.  
  152.     img[imgnum].t = t;
  153.     img[imgnum].l = l;
  154.  
  155.     return(OK);
  156.  
  157. }
  158.  
  159.  
  160. save_IMG_back(imgnum, l, t)
  161.  
  162. int l, t;
  163. char imgnum;
  164.  
  165. {
  166.  
  167. unsigned int j, k, w, h, n, m;
  168. char far *sp1;
  169. char far *sp2;
  170.  
  171. sp2 = img[imgnum].sptr;
  172. w =   img[imgnum].w;
  173. h =   img[imgnum].h;
  174. m =   0;
  175.  
  176. for (j = 0; j < h; j++)
  177.     {
  178.     sp1 = g_FPtr(sbptr, (t * 320) + (j * 320) + l);
  179.     n = 0;
  180.     for (k = 0; k < w; k++)
  181.         sp2[m++] = sp1[n++];
  182.     }
  183.  
  184. return(OK);
  185.  
  186. }
  187.  
  188.  
  189. removeimg(imgnum)
  190. char imgnum;
  191.  
  192. {
  193.  
  194. unsigned int j, k, n, t, l, w, h, m;
  195. char far *sp1;
  196. char far *sp2;
  197.  
  198. if (img[imgnum].sptr == NULL)
  199.    return(-1);               // Image is not on screen
  200.  
  201. sp2 = img[imgnum].sptr;
  202. t   = img[imgnum].t;
  203. l   = img[imgnum].l;
  204. w   = img[imgnum].w;
  205. h   = img[imgnum].h;
  206.  
  207. m   = 0;
  208.  
  209.  
  210. for (j = 0; j < h; j++)
  211.     {
  212.     if (j+t < 200)
  213.        {
  214.        sp1 = g_FPtr(sbptr, (t * 320) + (j * 320) + l);
  215.        n = 0;
  216.        for (k = 0; k < w; k++)
  217.            {
  218.            if (k+l < 320)
  219.               sp1[n] = sp2[m];
  220.            n++; m++;
  221.            }
  222.        }
  223.     }
  224.  
  225.     farfree(img[imgnum].sptr);
  226.     img[imgnum].sptr = 0;
  227.  
  228. return(OK);
  229.  
  230. }
  231.  
  232.  
  233. load_img(char *filnam, char append)
  234. {
  235.  
  236. int j, k, w, h;
  237. FILE *fp;
  238. char far *t;
  239. char sig[21];
  240.  
  241. if ( (fp = fopen(filnam, "rb")) == NULL)
  242.    return(NO_FILE);
  243.  
  244. if (append)
  245.    {
  246.    for (j=0; j<50; j++)
  247.        if (img[j].ptr == NULL)
  248.           break;
  249.    }
  250. else
  251.    j=0;
  252.  
  253. fread(sig, 1, 10, fp);
  254. sig[10] = 0;
  255.  
  256. if ( strcmp("Image File", sig) != NULL)
  257.    return(NOT_KNOWN);
  258.  
  259. while (!feof(fp) && j < 50)
  260.    {
  261.    if (fgetc(fp) != 255)
  262.       break;
  263.  
  264.    w = (int)fgetc(fp);
  265.    h = (int)fgetc(fp);
  266.  
  267.    t = farcalloc(w*h, 1);
  268.  
  269.    fread(t, 1, w*h, fp);
  270.  
  271.    img[j].ptr = t;
  272.    img[j].w   = w;
  273.    img[j++].h = h;
  274.    }
  275.  
  276.   while (j++ < 50)
  277.      {
  278.      img[j].ptr = NULL;
  279.      img[j].w   = 0;
  280.      img[j].h   = 0;
  281.      }
  282.  
  283.  
  284.  
  285. return(OK);
  286.  
  287. }
  288.